﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using IUAP.DAL.Intranet;
using System.Data;

/// <summary>
/// Descripción breve de IntranetProvider
/// </summary>
namespace IUAP.DAL.Provider
{
    public abstract class IntranetProvider : DataAccess
    {
        static private IntranetProvider _instance = null;
        static public IntranetProvider Instance
        {
            get
            {
                if (_instance == null)
                    _instance = (IntranetProvider)Activator.CreateInstance(
                       Type.GetType(Globals.Settings.Intranet.ProviderType));
                return _instance;
            }
        }

        public IntranetProvider()
        {
            this.ConnectionString = Globals.Settings.Intranet.ConnectionString;
            this.EnableCaching = Globals.Settings.Intranet.EnableCaching;
            this.CacheDuration = Globals.Settings.Intranet.CacheDuration;
        }

        // métodos que trabajarán con las facultades
        public abstract List<FacultadDetalles> GetFacultades(bool estado);/********HECHO*******/
        public abstract int InsertFacultad(FacultadDetalles facultad);/********HECHO*******/
        public abstract bool UpdateFacultad(FacultadDetalles facultad);/********HECHO*******/
        public abstract List<FacultadDetalles> GetSimFacultades(bool estado);/********HECHO*******/
        public abstract int GetCountFacultad(bool estado);/********HECHO*******/
        public abstract FacultadDetalles GetFacultadbyID(int id_facultad);

        // métodos que trabajarán con las escuelas
        public abstract List<EscuelaDetalles> GetEscuelas(bool estado);/********HECHO*******/
        public abstract List<EscuelaDetalles> GetEscuelas(int id_facultad, bool estado);/********HECHO*******/
        public abstract int InsertEscuela(EscuelaDetalles escuela);/********HECHO*******/
        public abstract bool UpdateEscuela(EscuelaDetalles escuela);/********HECHO*******/
        public abstract List<EscuelaDetalles> GetSimEscuelas(int id_facultad, bool estado);/********HECHO*******/
        public abstract int GetCountEscuela(bool estado);/********HECHO*******/
        public abstract List<EscuelaDetalles> GetSimEscuelabyDocente(string id_docente, bool estado);/********HECHO*******/

        // métodos que trabajarán con los cursos
        public abstract List<CursoDetalles> GetCursosbyEscuela(int id_escuela, int pageIndex, int pageSize);/********HECHO*******/
        public abstract List<CursoDetalles> GetCursosbyEscuela(string parametro, int tipo_parametro, int id_escuela, int pageIndex, int pageSize);/********HECHO*******/
        /*tipo_parametro = 0 , getCursobyEscuela-Nombre*/
        /*tipo_parametro = 1 , getCursobyEscuela-Semestre*/
        public abstract int GetCountCursos(int id_escuela);/********HECHO*******/
        public abstract int InsertCurso(CursoDetalles curso);/********HECHO*******/
        public abstract bool UpdateCurso(CursoDetalles curso);/********HECHO*******/
        public abstract bool UpdateEstadoCurso(int id_curso, bool estado);/********HECHO*******/
        
        // métodos que trabajarán con los periodos
        public abstract int InsertPeriodo(PeriodoDetalles periodo);/********HECHO*******/
        public abstract bool UpdatePeriodo(PeriodoDetalles periodo);/********HECHO*******/
        public abstract bool UpdateEstadoPeriodo(int id_periodo, bool estado);/********HECHO*******/
        public abstract List<PeriodoDetalles> GetPeriodos(bool estado);/********HECHO*******/
        public abstract List<PeriodoDetalles> GetSimPeriodos(bool estado);/********HECHO*******/
        public abstract List<PeriodoDetalles> GetSimPeriodos(bool estado, int id_escuela, string id_docente);/********HECHO*******/
        /* getSimPeriodobyDocente*/
        
        // métodos que trabajarán con los cursos en periodo
        public abstract List<int> GetSemestres(int id_escuela, int id_periodo);/********HECHO*******/
        public abstract List<CursoEnPeriodoDetalles> GetCursoEnPeriodo(int id_escuela, int id_periodo, int pageIndex, int pageSize);/********HECHO*******/
        public abstract List<CursoDetalles> GetCursobyDocente(string id_docente, int id_escuela, int id_periodo);/********HECHO*******/
        public abstract bool InsertFormula(int id_curso, int id_periodo, string formula);/********HECHO*******/
        public abstract int InsertCursoEnPeriodo(CursoEnPeriodoDetalles cursoenperiodo);/********HECHO*******/
        public abstract bool UpdateCursoEnPeriodo(int id_curso,int id_periodo,string doce_usua);/********HECHO*******/
        public abstract bool UpdateCierreCursoEnPeriodo(int id_periodo, int id_curso, bool cierre);/********HECHO*******/
        public abstract bool UpdateEncuestaCursoEnPeriodo(int id_periodo, int id_curso, bool estado);/********HECHO*******/
        public abstract bool DeleteCursoEnPeriodo(int id_curso, int id_periodo);/********HECHO*******/

        // métodos que trabajarán con los horarios
        public abstract int InsertHorario(HorarioDetalles horario);/********HECHO*******/
        public abstract bool UpdateHorario(HorarioDetalles horario);/********HECHO*******/

        // métodos que trabajarán con las mallas
        public abstract List<MallaDetalles> GetCursosEnPeriodoActivo(string id_alumno);/********HECHO*******/
        public abstract MallaDetalles GetCursoEnPeriodoActivo(string id_alumno, int id_periodo);/********HECHO*******/
        public abstract List<PeriodoDetalles> GetPeriodosbyAlumno(string id_alumno, bool estado);/********HECHO*******/
        public abstract CursoDetalles GetDetalleCurso(int id_curso);/********HECHO*******/

        // métodos que trabajarán con los administradores
        public abstract List<AdministradorDetalles> GetAdministradores();

        // métodos que trabajarán con los docentes
        public abstract DocenteDetalles GetDocentes(string id_docente);
        public abstract List<DocenteDetalles> GetDocentesbyApellido(string apepaterno);
         
        // métodos que trabajarán con las notas
        public abstract int InsertNota(NotaDetalles nota);/********HECHO*******/
        public abstract bool UpdateNota(NotaDetalles nota);/********HECHO*******/
        public abstract NotaDetalles GetNotasbyAlumno(int id_curso, int id_periodo, string id_alumno);/********HECHO*******/

        // métodos que trabajarán con las asistencias
        public abstract int InsertAsistencia(AsistenciasDetalles asistencia);/********HECHO*******/
        public abstract bool UpdateAsistencia(int id_asistencia,bool esta_asis);/********HECHO*******/
        public abstract List<AsistenciasDetalles> GetAsistenciasbyAlumno(int id_curso, int id_periodo, string id_alumno
            , DateTime fecha_inicio, DateTime fecha_termino);/********HECHO*******/

        // métodos que trabajarán con los alumnos
        public abstract AlumnoDetalles GetAlumnos(int id_escuela, string id_alumno);
        public abstract List<AlumnoDetalles> GetAlumnosbyApellido(int id_escuela, string apepaterno);

        protected virtual AdministradorDetalles GetAdministradorFromReader(IDataReader reader)
        {
            return new AdministradorDetalles(
                reader["id_administrador"].ToString(),
                reader["nomb_administrador"].ToString());
        }

        protected virtual List<AdministradorDetalles> GetAdministradorCollectionFromReader(IDataReader reader)
        {
            List<AdministradorDetalles> administradores = new List<AdministradorDetalles>();
            while (reader.Read())
                administradores.Add(GetAdministradorFromReader(reader));
            return administradores;
        }

        protected virtual AlumnoDetalles GetAlumnoFromReader(IDataReader reader)
        {
            return new AlumnoDetalles(
                reader["id_alumno"].ToString(),
                reader["nomb_alumno"].ToString());                
        }

        protected virtual List<AlumnoDetalles> GetAlumnoCollectionFromReader(IDataReader reader)
        {
            List<AlumnoDetalles> alumnos = new List<AlumnoDetalles>();
            while (reader.Read())
                alumnos.Add(GetAlumnoFromReader(reader));
            return alumnos;
        }

        protected virtual AsistenciasDetalles GetAsistenciaFromReader(IDataReader reader)
        {
            return new AsistenciasDetalles(
                (int)reader["id_asistencia"],
                (int)reader["id_curso"],
                (int)reader["id_periodo"],
                reader["alum_usua"].ToString(),
                (string)reader["fech_asis"],
                reader["esta_asis"].ToString());
        }

        protected virtual List<AsistenciasDetalles> GetAsistenciaCollectionFromReader(IDataReader reader)
        {
            List<AsistenciasDetalles> asistencias = new List<AsistenciasDetalles>();
            while (reader.Read())
                asistencias.Add(GetAsistenciaFromReader(reader));
            return asistencias;
        }

        protected virtual CursoDetalles GetCursoFromReader(IDataReader reader)
        {
            return new CursoDetalles(
                (int)reader["id_curso"],
                (int)reader["id_escuela"],
                reader["nomb_curs"].ToString(),
                (int)reader["cred_curs"],
                (bool)reader["tipo_curs"],
                (int)reader["seme_curs"],
                (bool)reader["actv_curs"]);
        }

        protected virtual List<CursoDetalles> GetCursoCollectionFromReader(IDataReader reader)
        {
            List<CursoDetalles> cursos = new List<CursoDetalles>();
            while (reader.Read())
                cursos.Add(GetCursoFromReader(reader));
            return cursos;
        }

        protected virtual CursoEnPeriodoDetalles GetCursoEnPeriodoFromReader(IDataReader reader)
        {
            return new CursoEnPeriodoDetalles(
                (int)reader["id_curso"],
                (int)reader["id_periodo"],
                reader["doce_usua"].ToString(),
                (bool)reader["cierre_curso"],
                (bool)reader["actv_encu"],
                reader["form_curso"].ToString());
        }

        protected virtual List<CursoEnPeriodoDetalles> GetCursoEnPeriodoCollectionFromReader(IDataReader reader)
        {
            List<CursoEnPeriodoDetalles> cursosenperiodo = new List<CursoEnPeriodoDetalles>();
            while (reader.Read())
                cursosenperiodo.Add(GetCursoEnPeriodoFromReader(reader));
            return cursosenperiodo;
        }

        protected virtual List<int> GetCursoEnPeriodoSemCollectionFromReader(IDataReader reader)
        {
            List<int> semestres = new List<int>();
            while (reader.Read())
                semestres.Add((int)reader["seme_curs"]);
            return semestres;
        }

        protected virtual DocenteDetalles GetDocenteFromReader(IDataReader reader)
        {
            return new DocenteDetalles(
                reader["id_docente"].ToString(),
                reader["nomb_docente"].ToString());
        }

        protected virtual List<DocenteDetalles> GetDocenteCollectionFromReader(IDataReader reader)
        {
            List<DocenteDetalles> docentes = new List<DocenteDetalles>();
            while (reader.Read())
                docentes.Add(GetDocenteFromReader(reader));
            return docentes;
        }

        protected virtual EscuelaDetalles GetEscuelaFromReader(IDataReader reader)
        {
            return new EscuelaDetalles(
                (int)reader["id_escuela"],
                (int)reader["id_facultad"],
                reader["nomb_escuela"].ToString(),
                reader["coor_usua"].ToString(),
                (bool)reader["esta_escuela"]);
        }

        protected virtual List<EscuelaDetalles> GetEscuelaCollectionFromReader(IDataReader reader)
        {
            List<EscuelaDetalles> escuelas = new List<EscuelaDetalles>();
            while (reader.Read())
                escuelas.Add(GetEscuelaFromReader(reader));
            return escuelas;
        }

        protected virtual FacultadDetalles GetFacultadFromReader(IDataReader reader)
        {
            return new FacultadDetalles(
                (int)reader["id_facultad"],
                reader["nomb_facultad"].ToString(),
                reader["dire_usua"].ToString(),
                (bool)reader["esta_facultad"]);
        }

        protected virtual List<FacultadDetalles> GetFacultadCollectionFromReader(IDataReader reader)
        {
            List<FacultadDetalles> facultades = new List<FacultadDetalles>();
            while (reader.Read())
                facultades.Add(GetFacultadFromReader(reader));
            return facultades;
        }

        protected virtual HorarioDetalles GetHorarioFromReader(IDataReader reader)
        {
            return new HorarioDetalles(
                (int)reader["id_horario"],
                (int)reader["id_curso"],
                (int)reader["id_periodo"],
                reader["dia_hora"].ToString(),
                reader["hoin_hora"].ToString(),
                reader["hofi_hora"].ToString(),
                reader["loca_hora"].ToString(),
                reader["aula_hora"].ToString());
        }

        protected virtual List<HorarioDetalles> GetHorarioCollectionFromReader(IDataReader reader)
        {
            List<HorarioDetalles> horarios = new List<HorarioDetalles>();
            while (reader.Read())
                horarios.Add(GetHorarioFromReader(reader));
            return horarios;
        }

        protected virtual MallaDetalles GetMallaFromReader(IDataReader reader)
        {
            return new MallaDetalles(
                reader["id_alumno"].ToString(),
                reader["nomb_alumno"].ToString(),
                (int)reader["id_curso"],
                (int)reader["id_periodo"]);
        }

        protected virtual List<MallaDetalles> GetMallaCollectionFromReader(IDataReader reader)
        {
            List<MallaDetalles> mallas = new List<MallaDetalles>();
            while (reader.Read())
                mallas.Add(GetMallaFromReader(reader));
            return mallas;
        }

        protected virtual NotaDetalles GetNotaFromReader(IDataReader reader)
        {
            return new NotaDetalles(
                (int)reader["id_nota"],
                (int)reader["id_curso"],
                (int)reader["id_periodo"],
                reader["alum_usua"].ToString(),
                (int)reader["on_asis_nota"],
                (int)reader["on_trab_nota"],
                (int)reader["on_inte_nota"],
                (int)reader["on_otro_nota"],
                (int)reader["pra1_nota"],
                (int)reader["pra2_nota"],
                (int)reader["parc_nota"],
                (int)reader["fina_nota"],
                (int)reader["sust_nota"],
                (int)reader["prom_nota"]);
        }

        protected virtual List<NotaDetalles> GetNotaCollectionFromReader(IDataReader reader)
        {
            List<NotaDetalles> notas = new List<NotaDetalles>();
            while (reader.Read())
                notas.Add(GetNotaFromReader(reader));
            return notas;
        }

        protected virtual PeriodoDetalles GetPeriodoFromReader(IDataReader reader)
        {
            return new PeriodoDetalles(
                (int)reader["id_periodo"],
                reader["nomb_peri"].ToString(),
                reader["desc_peri"].ToString(),
                (DateTime)reader["fech_inic_peri"],
                (DateTime)reader["fech_term_peri"],
                (bool)reader["actv_peri"]);
        }
        protected virtual List<PeriodoDetalles> GetPeriodoCollectionFromReader(IDataReader reader)
        {
            List<PeriodoDetalles> periodos = new List<PeriodoDetalles>();
            while (reader.Read())
                periodos.Add(GetPeriodoFromReader(reader));
            return periodos;
        }
    }
}